// utils/interceptors.js - 请求和响应拦截器

/**
 * 创建请求拦截器
 * @param {Function} callback - 拦截器回调函数
 */
const requestInterceptors = [];
const responseInterceptors = [];

/**
 * 添加请求拦截器
 * @param {Function} interceptor - 拦截器函数
 */
const addRequestInterceptor = (interceptor) => {
	requestInterceptors.push(interceptor);
};

/**
 * 添加响应拦截器
 * @param {Function} interceptor - 拦截器函数
 */
const addResponseInterceptor = (interceptor) => {
	responseInterceptors.push(interceptor);
};

/**
 * 处理请求拦截
 * @param {Object} options - 请求配置
 * @returns {Object} - 处理后的请求配置
 */
const processRequest = (options) => {
	let processedOptions = {
		...options
	};

	// 应用所有请求拦截器
	requestInterceptors.forEach(interceptor => {
		processedOptions = interceptor(processedOptions);
	});

	return processedOptions;
};

/**
 * 处理响应拦截
 * @param {Object} response - 响应数据
 * @param {Object} options - 请求配置
 * @returns {Object} - 处理后的响应数据
 */
const processResponse = (response, options) => {
	let processedResponse = {
		...response
	};

	// 应用所有响应拦截器
	responseInterceptors.forEach(interceptor => {
		processedResponse = interceptor(processedResponse, options);
	});

	return processedResponse;
};

// utils/request.js - 集成拦截器的请求封装

import {
	processRequest,
	processResponse
} from './interceptors';

/**
 * 封装uni.request请求方法 (带拦截器)
 * @param {Object} options - 请求配置
 * @returns {Promise} - 返回Promise对象
 */
const request = (options) => {
	// 处理请求地址
	const baseURL = 'http://192.168.10.102:8081/pet';
	const url = options.url.startsWith('http') ? options.url : baseURL + options.url;

	// 处理请求头
	const header = {
		'Content-Type': 'application/x-www-form-urlencoded',
		...options.header
	};

	// 获取并添加token (如果存在)
	const token = uni.getStorageSync('token');
	if (token) {
		header['token'] = `${token}`;
	}

	// 构建请求配置
	const requestOptions = {
		url,
		data: options.data || {},
		method: options.method || 'GET',
		header,
		timeout: options.timeout || 60000
	};

	// 应用请求拦截器
	const processedOptions = processRequest(requestOptions);

	// 返回Promise对象
	return new Promise((resolve, reject) => {
		uni.request({
			...processedOptions,

			// 请求成功回调
			success: (res) => {
				// 应用响应拦截器
				const processedResponse = processResponse(res, processedOptions);

				// 根据自己的业务逻辑判断请求是否成功
				if (processedResponse.statusCode === 200) {
					if (processedResponse.data.code === 0) {
						// 业务层面成功
						resolve(processedResponse.data.data);
					} else if (processedResponse.data.code === 401) {
						// token失效
						uni.removeStorageSync('token');
						uni.showToast({
							title: '登录状态已过期，请重新登录',
							icon: 'none'
						});

						// 1.5秒后跳转到登录页
						setTimeout(() => {
							uni.navigateTo({
								url: '/pages/login/login'
							});
						}, 1500);

						reject(processedResponse.data);
					} else {
						// 其他业务错误
						uni.showToast({
							title: processedResponse.data.message || '请求失败',
							icon: 'none'
						});
						reject(processedResponse.data);
					}
				} else {
					// HTTP状态码错误
					uni.showToast({
						title: `网络请求错误: ${processedResponse.statusCode}`,
						icon: 'none'
					});
					reject(processedResponse);
				}
			},

			// 请求失败回调
			fail: (err) => {
				uni.showToast({
					title: '网络异常，请检查网络连接',
					icon: 'none'
				});
				reject(err);
			},

			// 请求完成回调 (成功或失败都会执行)
			complete: () => {
				// 可以在这里关闭loading等
				uni.hideLoading();
			}
		});
	});
};

// 使用示例：添加日志拦截器
// main.js 中配置拦截器

import {
	addRequestInterceptor,
	addResponseInterceptor
} from '@/utils/interceptors';

// 请求拦截器：添加时间戳
addRequestInterceptor((options) => {
	console.log('发起请求:', options.url, options.data);

	// 防止GET请求缓存
	if (options.method === 'GET') {
		options.data = {
			...options.data,
			_t: Date.now()
		};
	}

	return options;
});

// 响应拦截器：打印响应日志
addResponseInterceptor((response, options) => {
	console.log('收到响应:', options.url, response.data);
	return response;
});

// 响应拦截器：全局错误处理
addResponseInterceptor((response, options) => {
	// 全局错误码处理
	if (response.data && response.data.code === 500) {
		uni.showToast({
			title: '服务器内部错误',
			icon: 'none'
		});
	}

	return response;
});